An Adaptive Parallel Algorithm for Computing Connectivity

Computing connected components in undirected graphs is a fundamental problem in graph analytics. The size of graph data collections continues to grow in many different scientific domains, which motivates the need for high performance distributed memory parallel graph algorithms, especially for large networks that cannot fit into the memory of a single compute node. For a graph G(V,E) with n vertices and m edges, two vertices belong to the same connected component iff there is a path between the two vertices in G. Sequentially, this problem can be solved in linear O(m) time, e.g. by using one of the following two approaches. One approach is to use either Breadth First (BFS) or Depth First Search (DFS) for each component. Another technique is to use a union-find based algorithm, where each vertex is initially assumed to be a different graph component and components connected by an edge are iteratively merged. There are known work-optimal and practical parallel solutions for computing BFS traversals on distributed memory systems. While parallel BFS algorithms have been optimized for traversing a short diameter big graph component, they can still be utilized for finding connectivity using multiple executions, one per connected component. However, for graphs with large number of small components, parallel BFS needs to be executed one after another, because unless a component is identified, a vertex not in the component cannot be chosen to initiate search for the next connected component. On the contrary, the classic Shiloach-Vishkin (SV) algorithm [1], a widely known PRAM algorithm for computing connectivity, simultaneously computes connectivity of all vertices and promises convergence in logarithmic iterations making it suitable for components with large diameter, as well as for graphs with a large number of small sized components. Compared to the simple label propagation techniques, the SV algorithm bounds the number of iterations to O(log n) instead of O(n), where each iteration is equivalent to O(m) work.